package com.hudilao.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hudilao.common.BaseContext;
import com.hudilao.common.R;
import com.hudilao.dto.OrderItemReviewDTO;
import com.hudilao.dto.OrderReviewDTO;
import com.hudilao.dto.OrderReviewDetailDTO;
import com.hudilao.entity.*;
import com.hudilao.mapper.OrderReviewMapper;
import com.hudilao.service.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;


@Service
@Slf4j
@Transactional
public class OrderReviewServiceImpl extends ServiceImpl<OrderReviewMapper, OrderReview> implements OrderReviewService {

    @Autowired
    private OrderReviewMapper orderReviewMapper;

    @Autowired
    private OrderDetailService orderDetailService;

    @Autowired
    private OrderService orderService;

    @Autowired
    private OrderItemReviewService orderItemReviewService;

    @Autowired
    private CustomerService customerService;


    /**
     *用户端 客户进行订单评价
     * @param orderReviewDTO 订单评价
     * @return 评价结果
     */
    @Override
    public R<String> add(OrderReviewDTO orderReviewDTO) {
        //获取当前客户
        long customerId = BaseContext.getCurrentId();

        //检查当前用户是否存在
        Customer customer = customerService.getById(customerId);
        if (customer == null) {
            return R.error("用户不存在");
        }

        // 验证请求参数
        if (orderReviewDTO.getReviewText() == null || orderReviewDTO.getReviewText().isEmpty()) {
            return R.error("订单评价信息不完整");
        }

        // 检查订单是否存在
        Order order = orderService.getById(orderReviewDTO.getOrderId());
        if (order == null) {
            return R.error("订单不存在");
        }

        // 检查订单是否属于当前用户
        if (!order.getCustomerId().equals(customerId)) {
            return R.error("用户无权评价此订单");
        }



        //检查订单是否已被评价过
        if(order.getStatus().equals(Order.REVIEWED)){
            return R.error("用户已评价过该订单");
        }

        // 验证每个菜品是否在订单中存在
        // 获取订单详情
        List<OrderDetail> orderDetails = orderDetailService.getOrderDetailsByOrderId(order.getId());
        for (OrderItemReviewDTO orderItemReviewDTO : orderReviewDTO.getOrderItemReviewDTOS()) {
            boolean itemExistsInOrder = orderDetails.stream()
                    .anyMatch(orderDetail -> orderDetail.getItemId().equals(orderItemReviewDTO.getItemId()));

            if (!itemExistsInOrder) {
                return R.error("订单中不存在菜品ID: " + orderItemReviewDTO.getItemId());
            }
        }

        // 计算菜品评分的平均值
        // 计算菜品评分的平均值并四舍五入取整
        int averageRating = (int) Math.round(orderReviewDTO.getOrderItemReviewDTOS().stream()
                .mapToInt(OrderItemReviewDTO::getRating)
                .average()
                .orElse(0));

        // 创建orderReview
        long orderReviewId = IdWorker.getId();
        OrderReview orderReview = new OrderReview();
        BeanUtils.copyProperties(orderReviewDTO, orderReview);
        orderReview.setId(orderReviewId);
        orderReview.setRating(averageRating);
        orderReview.setCustomerId(customerId);
        boolean result = this.save(orderReview);

        //保存对每个菜品的评价
        for(OrderItemReviewDTO orderItemReviewDTO : orderReviewDTO.getOrderItemReviewDTOS()){

            //保存菜品评价
            OrderItemReview orderItemReview = new OrderItemReview();
            BeanUtils.copyProperties(orderItemReviewDTO, orderItemReview);
            orderItemReview.setOrderReviewId(orderReviewId);

            orderItemReviewService.save(orderItemReview);

        }

        if (result) {
            //修改订单状态为已评价
            order.setStatus(Order.REVIEWED);
            orderService.updateStatusByIdAfterReview(order.getId(),order.getStatus());

            return R.success("订单评价成功");
        } else {
            return R.error("订单评价失败");
        }
    }

    /**
     * 根据订单id获取该订单用户评价
     * @param orderId 订单id
     * @return 用户评论
     */
    @Override
    public String getReviewTextByOrderId(long orderId) {
        return orderReviewMapper.getReviewTextByOrderId(orderId);
    }

    /**
     * 根据订单id获取商家回复
     * @param orderId 订单id
     * @return 商家回复
     */
    @Override
    public String getReviewReplyByOrderId(long orderId) {
        return orderReviewMapper.getReviewReplyByOrderId(orderId);
    }

    //管理端：评价管理
    /**
     * 分页查询订单评价或根据订单号查询
     * @param page 当前页
     * @param pageSize 每页大小
     * @param orderId 订单号（可选）
     * @return 分页结果或订单评价列表
     */
    @Override
    public Object getOrderReviewsOrByOrderId(int page, int pageSize, Long orderId) {

        if (orderId != null) {

            return orderReviewMapper.selectOrderReviewByOrderId(orderId);
        } else {

            Page<OrderReviewDTO> orderReviewPage = new Page<>(page, pageSize);
            return orderReviewMapper.selectOrderReviews(orderReviewPage);
        }
    }


    /**管理端：
     * 根据评价id查询评价详情
     * @param orderId 评价
     * @return 分页结果或订单评价列表
     */
    @Override
    public OrderReviewDetailDTO getOrderReviewDetailByReviewId(Long orderId) {

        //查询评价详情
        return orderReviewMapper.selectOrderReviewDetailByReviewId(orderId);
    }


    /**管理端：
     * 保存管理员回复
     * @param orderId 评价
     * @param employeeReply 管理员回复
     * @return 分页结果或订单评价列表
     */
    @Override
    public void saveEmployeeReply(Long orderId, String employeeReply) {

        //查询订单评价
        //OrderReview orderReview = orderReviewMapper.selectById(orderId);

        //根据订单id查询评价表
        QueryWrapper<OrderReview> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("order_id", orderId);
        OrderReview orderReview =  orderReviewMapper.selectOne(queryWrapper);

        if (orderReview != null) {

            //设置保存管理员回复
            orderReview.setEmployeeReply(employeeReply);

            //将评价状态更改为已回复
            int status=OrderReview.REPLIED;
            orderReview.setStatus(status);
            log.info("---回复状态更改---");
            log.info(orderReview.getStatus().toString());

            //更新评价表
            //orderReviewMapper.updateById(orderReview);
            //Long orderId=orderReview.getOrderId();
            orderReviewMapper.updateByOrderId(orderId,employeeReply,status);
            //orderReviewMapper.updateByOrderId(orderReview);
        }
    }
}
